import { ref, reactive, computed, onMounted } from 'vue';

// 关卡数据
export const levels = [
  // 关卡 1（简单）
  ['#####', '#@$.#', '#####'],
  // 关卡 2（简单）
  [
    '  ###   ',
    '  #.#   ',
    '  # ####',
    '###$ $.#',
    '#. $@###',
    '####$#  ',
    '   #.#  ',
    '   ###  ',
  ],
  // 关卡 3（中等）
  [
    '#####    ',
    '#@  #    ',
    '# $$# ###',
    '# $ # #.#',
    '### ###.#',
    ' ##    .#',
    ' #   #  #',
    ' #   ####',
    ' #####   ',
  ],
  // 关卡 4（中等）
  [
    ' #######  ',
    ' #     ###',
    '##$###   #',
    '# @ $  $ #',
    '# ..# $ ##',
    '##..#   # ',
    ' ######## ',
  ],
  // 关卡 5（中等）
  [
    ' #### ',
    '##  # ',
    '#@$ # ',
    '##$ ##',
    '## $ #',
    '#.$  #',
    '#..*.#',
    '######',
  ],
  // 关卡 6（困难）
  [
    ' #####  ',
    ' #@ ### ',
    ' # $  # ',
    '### # ##',
    '#.# #  #',
    '#.$  # #',
    '#.   $ #',
    '########',
  ],
  // 关卡 7（困难）下面的图是ai生成,问题很大
  [
    '#########',
    '#.  .  .#',
    '#  $ $  #',
    '# $ @ $ #',
    '#  $ $  #',
    '#.  .  .#',
    '#########',
  ],
  // 关卡 8（困难）
  [
    '#########',
    '#.     .#',
    '#  # #  #',
    '# $ @ $ #',
    '#  # #  #',
    '#  $ $  #',
    '#.     .#',
    '#########',
  ],
  // 关卡 9（专家）
  [
    ' ######## ',
    ' #. . . # ',
    ' # $ $ $ #',
    ' #  @  # ',
    ' # $ $ $ #',
    ' #. . . # ',
    ' ######## ',
  ],
  // 关卡 10（专家）
  [
    '###########',
    '#.  .  .  #',
    '#  # # #  #',
    '# $ @ # $ #',
    '#  # # #  #',
    '#  $ $ $  #',
    '#.  .  .  #',
    '###########',
  ],
  // 关卡 11（专家）
  [
    '###########',
    '#.     .  #',
    '#  # # #  #',
    '# $   $ # #',
    '# # @ # $ #',
    '# # # # # #',
    '#  $   $  #',
    '#.     .  #',
    '###########',
  ],
  // 关卡 12（专家）
  [
    '  ########  ',
    '  #. . . #  ',
    '  # $ $ $ # ',
    ' ## # # # ##',
    ' #  @  #  # ',
    ' # $ $ $ #  ',
    '  #. . . #  ',
    '  ########  ',
  ],
  // 关卡 13（极限）
  [
    '###############',
    '#.  .  .  .  #',
    '#  # # # # #  #',
    '# $   $   $   #',
    '#  # # @ # #  #',
    '# $   $   $   #',
    '#  # # # # #  #',
    '#.  .  .  .  #',
    '###############',
  ],
  // 关卡 14（极限）
  [
    '###############',
    '#.     .     .#',
    '#  # # # # #  #',
    '# $   $   $   #',
    '#  # # @ # #  #',
    '# #   # #   # #',
    '#  $   $   $  #',
    '#  # # # # #  #',
    '#.     .     .#',
    '###############',
  ],
  // 关卡 15（极限）
  [
    '  ############  ',
    '  #.  .  .  . # ',
    '  # $   $   $ # ',
    ' ## # # # # # ##',
    ' #  # @ # #  # ',
    ' # #   # #   # #',
    ' #  $   $   $  #',
    '  #.  .  .  . # ',
    '  ############  ',
  ],
  // 关卡 16（终极）
  [
    '  #################  ',
    '  #.     .     .  #  ',
    '  #  # # # # # # #  #',
    '  # $   $   $   $ #  ',
    ' ## # # # @ # # # ##',
    ' #  # # # # # # #  #',
    ' # #   # #   # #   #',
    ' #  $   $   $   $  #',
    '  #.     .     .  #  ',
    '  #################  ',
  ],
];

// 本地存储键名
const STORAGE_KEY = 'sokoban-game-progress';
const CUSTOM_LEVELS_KEY = 'sokoban-custom-levels'; // 添加自定义关卡存储键名

export function useGameLogic() {
  // 游戏状态
  const currentLevel = ref(0);
  const gameMap = reactive([]);
  const playerPosition = reactive({ x: 0, y: 0 });
  const isGameWon = ref(false);
  const isAllLevelsCompleted = ref(false);
  const moveCount = ref(0); // 添加计步器
  const unlockedLevels = ref(1); // 已解锁的关卡数量，初始为1（第一关）

  // 从本地存储加载游戏进度
  const loadProgress = () => {
    try {
      const savedProgress = localStorage.getItem(STORAGE_KEY);
      if (savedProgress) {
        const progress = JSON.parse(savedProgress);
        unlockedLevels.value = progress.unlockedLevels || 1;
        currentLevel.value = progress.currentLevel || 0;
      }
    } catch (error) {
      console.error('加载游戏进度失败:', error);
    }
  };

  // 保存游戏进度到本地存储
  const saveProgress = () => {
    try {
      const progress = {
        unlockedLevels: unlockedLevels.value,
        currentLevel: currentLevel.value,
      };
      localStorage.setItem(STORAGE_KEY, JSON.stringify(progress));
    } catch (error) {
      console.error('保存游戏进度失败:', error);
    }
  };

  // 获取所有关卡（包括预设关卡和自定义关卡）
  const getAllLevels = computed(() => {
    const customLevels = getCustomLevels();
    return [...levels, ...customLevels];
  });

  // 计算属性：总关卡数
  const totalLevels = computed(() => getAllLevels.value.length);

  // 选择关卡
  const selectLevel = (levelIndex) => {
    console.log(
      '尝试选择关卡:',
      levelIndex,
      '已解锁关卡:',
      unlockedLevels.value
    );

    // 检查关卡是否存在
    if (levelIndex < 0 || levelIndex >= getAllLevels.value.length) {
      console.error('关卡不存在:', levelIndex);
      return false;
    }

    // 对于预设关卡，检查是否已解锁
    if (levelIndex < levels.length && levelIndex > unlockedLevels.value) {
      console.log('预设关卡未解锁');
      return false;
    }

    // 对于自定义关卡，始终允许选择
    currentLevel.value = levelIndex;
    initLevel();
    // 保存游戏进度
    saveProgress();
    return true;
  };

  // 获取指定关卡的数据
  const getLevelData = (levelIndex) => {
    const allLevels = getAllLevels.value;
    if (levelIndex >= 0 && levelIndex < allLevels.length) {
      return allLevels[levelIndex];
    }
    return null;
  };

  // 初始化当前关卡
  const initLevel = () => {
    gameMap.length = 0;
    isGameWon.value = false;
    moveCount.value = 0; // 重置计步器

    // 复制关卡数据到游戏地图
    const allLevels = getAllLevels.value;
    console.log(
      '初始化关卡:',
      currentLevel.value,
      '总关卡数:',
      allLevels.length
    );

    // 检查当前关卡是否存在
    if (!allLevels || currentLevel.value >= allLevels.length) {
      console.error('关卡数据不存在:', currentLevel.value);
      // 如果关卡不存在，回到第一关
      currentLevel.value = 0;
    }

    const levelData = allLevels[currentLevel.value];
    console.log('当前关卡数据:', levelData);

    // 确保levelData是有效的数组
    if (!Array.isArray(levelData) || levelData.length === 0) {
      console.error('无效的关卡数据');
      return;
    }

    // 检查关卡数据的每一行是否为字符串
    for (let i = 0; i < levelData.length; i++) {
      if (typeof levelData[i] !== 'string') {
        console.error('关卡数据格式错误，第', i, '行不是字符串:', levelData[i]);
        // 尝试转换为字符串
        if (Array.isArray(levelData[i])) {
          levelData[i] = levelData[i].join('');
        } else {
          levelData[i] = String(levelData[i]);
        }
      }
    }

    for (let y = 0; y < levelData.length; y++) {
      const row = levelData[y];
      const mapRow = [];

      for (let x = 0; x < row.length; x++) {
        const cell = row[x];
        mapRow.push(cell);

        // 找到玩家位置
        if (cell === '@' || cell === '+') {
          playerPosition.x = x;
          playerPosition.y = y;
        }
      }

      gameMap.push(mapRow);
    }

    console.log(
      '初始化完成，地图大小:',
      gameMap.length,
      'x',
      gameMap[0]?.length
    );
    console.log('玩家位置:', playerPosition.x, playerPosition.y);

    // 保存游戏进度
    saveProgress();
  };

  // 检查是否获胜（所有箱子都在目标点上）
  const checkWin = () => {
    for (let y = 0; y < gameMap.length; y++) {
      for (let x = 0; x < gameMap[y].length; x++) {
        // 如果还有箱子不在目标点上，游戏未获胜
        if (gameMap[y][x] === '$') {
          return false;
        }
      }
    }

    // 所有箱子都在目标点上，游戏获胜
    isGameWon.value = true;

    // 解锁下一关
    if (
      currentLevel.value + 1 > unlockedLevels.value &&
      currentLevel.value < levels.length - 1
    ) {
      unlockedLevels.value = currentLevel.value + 1;
      // 保存游戏进度
      saveProgress();
    }

    // 检查是否完成所有关卡
    if (currentLevel.value === levels.length - 1) {
      isAllLevelsCompleted.value = true;
    }

    return true;
  };

  // 获取指定位置的单元格类型
  const getCellType = (x, y) => {
    if (y < 0 || y >= gameMap.length || x < 0 || x >= gameMap[y].length) {
      return '#'; // 超出边界视为墙
    }
    return gameMap[y][x];
  };

  // 设置指定位置的单元格类型
  const setCellType = (x, y, type) => {
    if (y >= 0 && y < gameMap.length && x >= 0 && x < gameMap[y].length) {
      gameMap[y][x] = type;
    }
  };

  // 移动玩家
  const movePlayer = (dx, dy) => {
    if (isGameWon.value) return false;

    const newX = playerPosition.x + dx;
    const newY = playerPosition.y + dy;

    // 获取当前位置和目标位置的单元格类型
    const currentCell = getCellType(playerPosition.x, playerPosition.y);
    const targetCell = getCellType(newX, newY);

    // 如果目标位置是墙，不能移动
    if (targetCell === '#') {
      return false;
    }

    let moved = false; // 标记是否真正移动了

    // 如果目标位置是箱子，检查箱子能否被推动
    if (targetCell === '$' || targetCell === '*') {
      const behindX = newX + dx;
      const behindY = newY + dy;
      const behindCell = getCellType(behindX, behindY);

      // 如果箱子后面是墙或另一个箱子，不能推动
      if (behindCell === '#' || behindCell === '$' || behindCell === '*') {
        return false;
      }

      // 移动箱子
      if (behindCell === '.') {
        // 箱子推到目标点上
        setCellType(behindX, behindY, '*');
      } else {
        // 箱子推到空地上
        setCellType(behindX, behindY, '$');
      }

      // 更新原箱子位置
      if (targetCell === '*') {
        // 箱子原来在目标点上
        setCellType(newX, newY, '.');
      } else {
        // 箱子原来在空地上
        setCellType(newX, newY, ' ');
      }

      moved = true;
    }

    // 更新玩家原位置
    if (currentCell === '@') {
      // 玩家原来在空地上
      setCellType(playerPosition.x, playerPosition.y, ' ');
    } else if (currentCell === '+') {
      // 玩家原来在目标点上
      setCellType(playerPosition.x, playerPosition.y, '.');
    }

    // 更新玩家新位置
    if (targetCell === ' ' || targetCell === '$') {
      // 玩家移动到空地上
      setCellType(newX, newY, '@');
      moved = true;
    } else if (targetCell === '.' || targetCell === '*') {
      // 玩家移动到目标点上
      setCellType(newX, newY, '+');
      moved = true;
    }

    // 更新玩家位置
    playerPosition.x = newX;
    playerPosition.y = newY;

    // 增加步数计数
    if (moved) {
      moveCount.value++;
    }

    // 检查是否获胜
    checkWin();

    return moved;
  };

  // 处理键盘输入
  const handleKeyDown = (event) => {
    let moved = false;

    switch (event.key) {
      case 'ArrowUp':
      case 'w':
      case 'W':
        moved = movePlayer(0, -1);
        break;
      case 'ArrowDown':
      case 's':
      case 'S':
        moved = movePlayer(0, 1);
        break;
      case 'ArrowLeft':
      case 'a':
      case 'A':
        moved = movePlayer(-1, 0);
        break;
      case 'ArrowRight':
      case 'd':
      case 'D':
        moved = movePlayer(1, 0);
        break;
      case 'r':
      case 'R':
        initLevel();
        moved = true;
        break;
    }

    if (moved) {
      event.preventDefault();
    }
  };

  // 进入下一关
  const nextLevel = () => {
    if (currentLevel.value < levels.length - 1) {
      currentLevel.value++;
      initLevel();
      // 保存游戏进度
      saveProgress();
    }
  };

  // 重置当前关卡
  const resetLevel = () => {
    initLevel();
  };

  // 重置整个游戏
  const resetGame = () => {
    currentLevel.value = 0;
    isGameWon.value = false;
    isAllLevelsCompleted.value = false; // 重置通关状态
    moveCount.value = 0;
    initLevel();
    // 保存游戏进度
    saveProgress();
  };

  // 计算属性：当前关卡编号（从1开始）
  const levelNumber = computed(() => currentLevel.value + 1);

  // 添加自定义关卡
  const addCustomLevel = (levelData) => {
    try {
      console.log('添加自定义关卡，原始数据:', levelData);

      // 验证关卡数据
      if (!Array.isArray(levelData) || levelData.length === 0) {
        throw new Error('无效的关卡数据');
      }

      // 确保每一行都是字符串
      const normalizedLevelData = levelData.map((row) => {
        if (typeof row !== 'string') {
          if (Array.isArray(row)) {
            return row.join('');
          }
          return String(row);
        }
        return row;
      });

      console.log('规范化后的关卡数据:', normalizedLevelData);

      // 验证关卡格式
      let hasPlayer = false;
      let boxCount = 0;
      let targetCount = 0;

      for (const row of normalizedLevelData) {
        for (const cell of row) {
          if (cell === '@' || cell === '+') hasPlayer = true;
          if (cell === '$' || cell === '*') boxCount++;
          if (cell === '.' || cell === '+' || cell === '*') targetCount++;
        }
      }

      if (!hasPlayer) {
        throw new Error('关卡中必须包含玩家');
      }
      if (boxCount === 0) {
        throw new Error('关卡中必须包含箱子');
      }
      if (boxCount !== targetCount) {
        throw new Error('箱子数量必须等于目标点数量');
      }

      // 获取已保存的自定义关卡
      let savedCustomLevels = [];
      try {
        const savedData = localStorage.getItem(CUSTOM_LEVELS_KEY);
        if (savedData) {
          savedCustomLevels = JSON.parse(savedData);
          if (!Array.isArray(savedCustomLevels)) {
            console.warn('已保存的自定义关卡不是数组格式，重置为空数组');
            savedCustomLevels = [];
          }
        }
      } catch (e) {
        console.error('读取自定义关卡失败，重置为空数组', e);
        savedCustomLevels = [];
      }

      // 添加新关卡
      savedCustomLevels.push(normalizedLevelData);

      // 保存更新后的自定义关卡
      localStorage.setItem(
        CUSTOM_LEVELS_KEY,
        JSON.stringify(savedCustomLevels)
      );

      console.log('保存自定义关卡成功:', normalizedLevelData);
      console.log('当前所有自定义关卡:', savedCustomLevels);

      return true;
    } catch (error) {
      console.error('添加自定义关卡失败:', error);
      return false;
    }
  };

  // 获取自定义关卡列表
  const getCustomLevels = () => {
    try {
      const customLevelsData = localStorage.getItem(CUSTOM_LEVELS_KEY);
      if (!customLevelsData) {
        console.log('没有找到自定义关卡数据');
        return [];
      }

      const parsedData = JSON.parse(customLevelsData);
      console.log('解析自定义关卡数据:', parsedData);

      // 确保返回的是数组格式
      if (!Array.isArray(parsedData)) {
        console.error('自定义关卡数据不是数组格式');
        return [];
      }

      // 验证每个关卡的格式
      const validLevels = parsedData.filter((level, index) => {
        if (!Array.isArray(level)) {
          console.error('关卡', index, '不是数组格式:', level);
          return false;
        }

        // 检查每行是否为字符串
        for (let i = 0; i < level.length; i++) {
          if (typeof level[i] !== 'string') {
            console.error('关卡', index, '的第', i, '行不是字符串:', level[i]);
            return false;
          }
        }

        return true;
      });

      console.log('有效的自定义关卡数量:', validLevels.length);
      return validLevels;
    } catch (error) {
      console.error('获取自定义关卡失败:', error);
      return [];
    }
  };

  // 删除自定义关卡
  const deleteCustomLevel = (index) => {
    try {
      const savedCustomLevels = JSON.parse(
        localStorage.getItem(CUSTOM_LEVELS_KEY) || '[]'
      );
      if (index >= 0 && index < savedCustomLevels.length) {
        savedCustomLevels.splice(index, 1);
        localStorage.setItem(
          CUSTOM_LEVELS_KEY,
          JSON.stringify(savedCustomLevels)
        );
        return true;
      }
      return false;
    } catch (error) {
      console.error('删除自定义关卡失败:', error);
      return false;
    }
  };

  // 组件挂载时加载游戏进度
  onMounted(() => {
    loadProgress();
    initLevel();
  });

  return {
    gameMap,
    playerPosition,
    currentLevel,
    isGameWon,
    isAllLevelsCompleted,
    levelNumber,
    totalLevels,
    moveCount,
    unlockedLevels,
    initLevel,
    movePlayer,
    handleKeyDown,
    nextLevel,
    resetLevel,
    resetGame,
    selectLevel,
    loadProgress,
    saveProgress,
    getLevelData,
    addCustomLevel,
    getCustomLevels,
    deleteCustomLevel,
    getAllLevels,
  };
}
